Warzone.java

package com.tommytony.war;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.logging.Level;

import net.milkbowl.vault.economy.EconomyResponse;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Arrow;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Item;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.TNTPrimed;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.inventory.InventoryView;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.permissions.Permissible;
import org.bukkit.potion.PotionEffect;
import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Scoreboard;
import org.getspout.spoutapi.SpoutManager;
import org.getspout.spoutapi.player.SpoutPlayer;

import com.google.common.collect.ImmutableList;
import com.tommytony.war.config.InventoryBag;
import com.tommytony.war.config.ScoreboardType;
import com.tommytony.war.config.TeamConfig;
import com.tommytony.war.config.TeamConfigBag;
import com.tommytony.war.config.TeamKind;
import com.tommytony.war.config.WarzoneConfig;
import com.tommytony.war.config.WarzoneConfigBag;
import com.tommytony.war.event.WarBattleWinEvent;
import com.tommytony.war.event.WarPlayerLeaveEvent;
import com.tommytony.war.event.WarPlayerThiefEvent;
import com.tommytony.war.event.WarScoreCapEvent;
import com.tommytony.war.job.InitZoneJob;
import com.tommytony.war.job.LoadoutResetJob;
import com.tommytony.war.job.LogKillsDeathsJob;
import com.tommytony.war.job.LogKillsDeathsJob.KillsDeathsRecord;
import com.tommytony.war.mapper.LoadoutYmlMapper;
import com.tommytony.war.mapper.VolumeMapper;
import com.tommytony.war.mapper.ZoneVolumeMapper;
import com.tommytony.war.spout.SpoutDisplayer;
import com.tommytony.war.structure.Bomb;
import com.tommytony.war.structure.Cake;
import com.tommytony.war.structure.HubLobbyMaterials;
import com.tommytony.war.structure.Monument;
import com.tommytony.war.structure.WarzoneMaterials;
import com.tommytony.war.structure.ZoneLobby;
import com.tommytony.war.structure.ZoneWallGuard;
import com.tommytony.war.utility.Direction;
import com.tommytony.war.utility.Loadout;
import com.tommytony.war.utility.LoadoutSelection;
import com.tommytony.war.utility.PlayerState;
import com.tommytony.war.utility.PotionEffectHelper;
import com.tommytony.war.volume.Volume;
import com.tommytony.war.volume.ZoneVolume;

/**
 *
 * @author tommytony
 * @package com.tommytony.war
 */
public class Warzone {
	public enum LeaveCause {
		COMMAND, DISCONNECT, SCORECAP, RESET;
		public boolean useRallyPoint() {
			return this == SCORECAP ? true : false;
		}
	}

	private String name;
	private ZoneVolume volume;
	private World world;
	private final List<Team> teams = new ArrayList<Team>();
	private final List<Monument> monuments = new ArrayList<Monument>();
	private final List<Bomb> bombs = new ArrayList<Bomb>();
	private final List<Cake> cakes = new ArrayList<Cake>();
	private Location teleport;
	private ZoneLobby lobby;
	private Location rallyPoint;
	
	private final List<String> authors = new ArrayList<String>();
	
	private final int minSafeDistanceFromWall = 6;
	private List<ZoneWallGuard> zoneWallGuards = new ArrayList<ZoneWallGuard>();
	private HashMap<String, PlayerState> playerStates = new HashMap<String, PlayerState>();
	private HashMap<String, Team> flagThieves = new HashMap<String, Team>();
	private HashMap<String, Bomb> bombThieves = new HashMap<String, Bomb>();
	private HashMap<String, Cake> cakeThieves = new HashMap<String, Cake>();
	private HashMap<String, LoadoutSelection> loadoutSelections = new HashMap<String, LoadoutSelection>();
	private HashMap<String, PlayerState> deadMenInventories = new HashMap<String, PlayerState>();
	private HashMap<String, Integer> killCount = new HashMap<String, Integer>();
	private final List<Player> respawn = new ArrayList<Player>();
	private final List<String> reallyDeadFighters = new ArrayList<String>();

	private List<LogKillsDeathsJob.KillsDeathsRecord> killsDeathsTracker = new ArrayList<KillsDeathsRecord>();
	
	private final WarzoneConfigBag warzoneConfig;
	private final TeamConfigBag teamDefaultConfig;
	private InventoryBag defaultInventories = new InventoryBag();

	private Scoreboard scoreboard;
	
	private HubLobbyMaterials lobbyMaterials = null;
	private WarzoneMaterials warzoneMaterials = new WarzoneMaterials(
			new ItemStack(Material.OBSIDIAN), new ItemStack(Material.FENCE),
			new ItemStack(Material.GLOWSTONE));
	
	private boolean isEndOfGame = false;
	private boolean isReinitializing = false;
	//private final Object gameEndLock = new Object();

	public Warzone(World world, String name) {
		this.world = world;
		this.name = name;
		this.warzoneConfig = new WarzoneConfigBag(this);
		this.teamDefaultConfig = new TeamConfigBag();	// don't use ctor with Warzone, as this changes config resolution
		this.volume = new ZoneVolume(name, this.getWorld(), this);
		this.lobbyMaterials = War.war.getWarhubMaterials().clone();
	}

	public static Warzone getZoneByName(String name) {
		Warzone bestGuess = null;
		for (Warzone warzone : War.war.getWarzones()) {
			if (warzone.getName().toLowerCase().equals(name.toLowerCase())) {
				// perfect match, return right away
				return warzone;
			} else if (warzone.getName().toLowerCase().startsWith(name.toLowerCase())) {
				// perhaps there's a perfect match in the remaining zones, let's take this one aside
				bestGuess = warzone;
			}
		}
		return bestGuess;
	}

	public static Warzone getZoneByNameExact(String name) {
		for (Warzone zone : War.war.getWarzones()) {
			if (zone.getName().equalsIgnoreCase(name)) return zone;
		}
		return null;
	}

	public static Warzone getZoneByLocation(Location location) {
		for (Warzone warzone : War.war.getWarzones()) {
			if (location.getWorld().getName().equals(warzone.getWorld().getName()) && warzone.getVolume() != null && warzone.getVolume().contains(location)) {
				return warzone;
			}
		}
		return null;
	}

	public static Warzone getZoneByLocation(Player player) {
		return Warzone.getZoneByLocation(player.getLocation());
	}

	public static Warzone getZoneByPlayerName(String playerName) {
		for (Warzone warzone : War.war.getWarzones()) {
			Team team = warzone.getPlayerTeam(playerName);
			if (team != null) {
				return warzone;
			}
		}
		return null;
	}

	public static Warzone getZoneForDeadPlayer(Player player) {
		for (Warzone warzone : War.war.getWarzones()) {
			if (warzone.getReallyDeadFighters().contains(player.getName())) {
				return warzone;
			}
		}
		return null;
	}

	public boolean ready() {
		if (this.volume.hasTwoCorners() && !this.volume.tooSmall() && !this.volume.tooBig()) {
			return true;
		}
		return false;
	}

	public List<Team> getTeams() {
		return this.teams;
	}

	public Team getPlayerTeam(String playerName) {
		for (Team team : this.teams) {
			for (Player player : team.getPlayers()) {
				if (player.getName().equals(playerName)) {
					return team;
				}
			}
		}
		return null;
	}

	public String getTeamInformation() {
		StringBuilder teamsMessage = new StringBuilder(War.war.getString("zone.teaminfo.prefix"));
		if (this.getTeams().isEmpty()) {
			teamsMessage.append(War.war.getString("zone.teaminfo.none"));
		} else {
			for (Team team : this.getTeams()) {
				teamsMessage.append('\n');
				teamsMessage.append(MessageFormat.format(War.war.getString("zone.teaminfo.format"),
						team.getName(), team.getPoints(), team.getRemainingLifes(),
						team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL), StringUtils.join(team.getPlayerNames().iterator(), ", ")));
			}
		}
		return teamsMessage.toString();
	}

	public String getName() {
		return this.name;
	}

	@Override
	public String toString() {
		return this.getName();
	}

	public void setTeleport(Location location) {
		this.teleport = location;
	}

	public Location getTeleport() {
		return this.teleport;
	}

	public int saveState(boolean clearArtifacts) {
		if (this.ready()) {
			if (clearArtifacts) {
				// removed everything to keep save clean
				for (ZoneWallGuard guard : this.zoneWallGuards) {
					guard.deactivate();
				}
				this.zoneWallGuards.clear();

				for (Team team : this.teams) {
					for (Volume teamVolume : team.getSpawnVolumes().values()) {
						teamVolume.resetBlocks();
					}
					if (team.getTeamFlag() != null) {
						team.getFlagVolume().resetBlocks();
					}
				}

				for (Monument monument : this.monuments) {
					monument.getVolume().resetBlocks();
				}

				if (this.lobby != null) {
					this.lobby.getVolume().resetBlocks();
				}
			}

			this.volume.saveBlocks();
			if (clearArtifacts) {
				this.initializeZone(); // bring back stuff
			}
			return this.volume.size();
		}
		return 0;
	}

	/**
	 * Goes back to the saved state of the warzone (resets only block types, not physics). Also teleports all players back to their respective spawns.
	 *
	 * @return
	 */
	public void initializeZone() {
		this.initializeZone(null);
	}

	public void initializeZone(Player respawnExempted) {
		if (this.ready() && this.volume.isSaved()) {
			if (this.scoreboard != null) {
				for (OfflinePlayer opl : this.scoreboard.getPlayers()) {
					this.scoreboard.resetScores(opl);
				}
				this.scoreboard.clearSlot(DisplaySlot.SIDEBAR);
				for (Objective obj : this.scoreboard.getObjectives()) {
					obj.unregister();
				}
				for (Player player : Bukkit.getOnlinePlayers()) {
					if (player.getScoreboard() == this.scoreboard) {
						player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
					}
				}
				this.scoreboard = null;
			}
			// everyone back to team spawn with full health
			for (Team team : this.teams) {
				for (Player player : team.getPlayers()) {
					if (player.equals(respawnExempted)) {
						continue;
					}
					if (this.getReallyDeadFighters().contains(player.getName())) {
						continue;
					}
					this.respawnPlayer(team, player);
				}
				team.setRemainingLives(team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
				team.initializeTeamSpawns();
				if (team.getTeamFlag() != null) {
					team.setTeamFlag(team.getTeamFlag());
				}
			}

			this.initZone();
			
			if (War.war.getWarHub() != null) {
				War.war.getWarHub().resetZoneSign(this);
			}
		}
		
		// Don't forget to reset these to false, or we won't be able to score or empty lifepools anymore
		this.isReinitializing = false;
		this.isEndOfGame = false;
	}

	public void initializeZoneAsJob(Player respawnExempted) {
		InitZoneJob job = new InitZoneJob(this, respawnExempted);
		War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, job);
	}

	public void initializeZoneAsJob() {
		InitZoneJob job = new InitZoneJob(this);
		War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, job);
	}

	private void initZone() {
		// reset monuments
		for (Monument monument : this.monuments) {
			monument.getVolume().resetBlocks();
			monument.addMonumentBlocks();
		}
		
		// reset bombs
		for (Bomb bomb : this.bombs) {
			bomb.getVolume().resetBlocks();
			bomb.addBombBlocks();
		}
		
		// reset cakes
		for (Cake cake : this.cakes) {
			cake.getVolume().resetBlocks();
			cake.addCakeBlocks();
		}

		// reset lobby (here be demons)
		if (this.lobby != null) {
			if (this.lobby.getVolume() != null) {
				this.lobby.getVolume().resetBlocks();
			}
			this.lobby.initialize();
		}

		this.flagThieves.clear();
		this.bombThieves.clear();
		this.cakeThieves.clear();
		if (this.getScoreboardType() != ScoreboardType.NONE) {
			this.scoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
			scoreboard.registerNewObjective(this.getScoreboardType().getDisplayName(), "dummy");
			Objective obj = scoreboard.getObjective(this.getScoreboardType().getDisplayName());
			Validate.isTrue(obj.isModifiable(), "Cannot modify players' scores on the " + this.name + " scoreboard.");
			for (Team team : this.getTeams()) {
				String teamName = team.getKind().getColor() + team.getName() + ChatColor.RESET;
				if (this.getScoreboardType() == ScoreboardType.POINTS) {
					obj.getScore(Bukkit.getOfflinePlayer(teamName)).setScore(team.getPoints());
				} else if (this.getScoreboardType() == ScoreboardType.LIFEPOOL) {
					obj.getScore(Bukkit.getOfflinePlayer(teamName)).setScore(team.getRemainingLifes());
				}
			}
			obj.setDisplaySlot(DisplaySlot.SIDEBAR);
			for (Team team : this.getTeams()) {
				for (Player player : team.getPlayers()) {
					player.setScoreboard(scoreboard);
				}
			}
		}
		// nom drops
		for(Entity entity : (this.getWorld().getEntities())) {
			if (!(entity instanceof Item)) {
				continue;
			}
			
			// validate position
			if (!this.getVolume().contains(entity.getLocation())) {
				continue;
			}

			// omnomnomnom
			entity.remove();
		}
	}

	public void endRound() {

	}

	public void respawnPlayer(Team team, Player player) {
		this.handleRespawn(team, player);
		// Teleport the player back to spawn
		player.teleport(team.getRandomSpawn());
	}

	public void respawnPlayer(PlayerMoveEvent event, Team team, Player player) {
		this.handleRespawn(team, player);
		// Teleport the player back to spawn
		event.setTo(team.getRandomSpawn());
	}
	
	public boolean isRespawning(Player p) {
		return respawn.contains(p);
	}

	private void handleRespawn(final Team team, final Player player) {
		// Fill hp
		player.setRemainingAir(player.getMaximumAir());
		player.setHealth(player.getMaxHealth());
		player.setFoodLevel(20);
		player.setSaturation(team.getTeamConfig().resolveInt(TeamConfig.SATURATION));
		player.setExhaustion(0);
		player.setFallDistance(0);
		War.war.getServer().getScheduler().runTaskLater(War.war, new Runnable() {

			@Override
			public void run() {
				// Stop fire here, since doing it in the same tick as death doesn't extinguish it
				player.setFireTicks(0);
			}
			
		}, 1L);

		this.preventItemHackingThroughOpenedInventory(player);
		
		player.setLevel(0);
		player.setExp(0);
		player.setAllowFlight(false);
		player.setFlying(false);

		player.getInventory().clear();
		
		this.setKillCount(player.getName(), 0);

		if (player.getGameMode() != GameMode.SURVIVAL) {
			// Players are always in survival mode in warzones
			player.setGameMode(GameMode.SURVIVAL);
		}
		
		// clear potion effects
		PotionEffectHelper.clearPotionEffects(player);

		String potionEffect = team.getTeamConfig().resolveString(TeamConfig.APPLYPOTION);
		if (!potionEffect.isEmpty()) {
			PotionEffect effect = War.war.getPotionEffect(potionEffect);
			if (effect != null) {
				player.addPotionEffect(effect);
			} else {
				War.war.getLogger().log(Level.WARNING,
					"Failed to apply potion effect {0} in warzone {1}.",
					new Object[] {potionEffect, name});
			}
		}
		
		boolean isFirstRespawn = false;
		if (!this.getLoadoutSelections().keySet().contains(player.getName())) {
			isFirstRespawn = true;
			this.getLoadoutSelections().put(player.getName(), new LoadoutSelection(true, 0));
		} else if (this.isReinitializing) {
			isFirstRespawn = true;
			this.getLoadoutSelections().get(player.getName()).setStillInSpawn(true);
		} else {
			this.getLoadoutSelections().get(player.getName()).setStillInSpawn(true);
		}
		
		// Spout
		if (War.war.isSpoutServer()) {
			SpoutManager.getPlayer(player).setTitle(team.getKind().getColor() + player.getName());
		}

		War.war.getKillstreakReward().getAirstrikePlayers().remove(player.getName());

		final LoadoutResetJob job = new LoadoutResetJob(this, team, player, isFirstRespawn, false);
		if (team.getTeamConfig().resolveInt(TeamConfig.RESPAWNTIMER) == 0 || isFirstRespawn) {
			job.run();
		}			
		else {
			// "Respawn" Timer - player will not be able to leave spawn for a few seconds
			respawn.add(player);
			
			War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, new Runnable() {
				public void run() {
				    respawn.remove(player);
					War.war.getServer().getScheduler().scheduleSyncDelayedTask(War.war, job);
				}
			}, team.getTeamConfig().resolveInt(TeamConfig.RESPAWNTIMER) * 20L); // 20 ticks = 1 second
		}
	}

	public void resetInventory(Team team, Player player, Map<Integer, ItemStack> loadout) {
		// Reset inventory to loadout
		PlayerInventory playerInv = player.getInventory();
		playerInv.clear();
		playerInv.clear(playerInv.getSize() + 0);
		playerInv.clear(playerInv.getSize() + 1);
		playerInv.clear(playerInv.getSize() + 2);
		playerInv.clear(playerInv.getSize() + 3); // helmet/blockHead
		for (Integer slot : loadout.keySet()) {
			if (slot == 100) {
				playerInv.setBoots(loadout.get(slot).clone());
			} else if (slot == 101) {
				playerInv.setLeggings(loadout.get(slot).clone());
			} else if (slot == 102) {
				playerInv.setChestplate(loadout.get(slot).clone());
			} else if (slot == 103) {
				playerInv.setHelmet(loadout.get(slot).clone());
			} else {
				ItemStack item = loadout.get(slot);
				if (item != null) {
					playerInv.addItem(item.clone());
				}
			}
		}
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.BLOCKHEADS)) {
			playerInv.setHelmet(team.getKind().getHat());
		}
	}

	public boolean isMonumentCenterBlock(Block block) {
		for (Monument monument : this.monuments) {
			int x = monument.getLocation().getBlockX();
			int y = monument.getLocation().getBlockY() + 1;
			int z = monument.getLocation().getBlockZ();
			if (x == block.getX() && y == block.getY() && z == block.getZ()) {
				return true;
			}
		}
		return false;
	}

	public Monument getMonumentFromCenterBlock(Block block) {
		for (Monument monument : this.monuments) {
			int x = monument.getLocation().getBlockX();
			int y = monument.getLocation().getBlockY() + 1;
			int z = monument.getLocation().getBlockZ();
			if (x == block.getX() && y == block.getY() && z == block.getZ()) {
				return monument;
			}
		}
		return null;
	}

	public boolean nearAnyOwnedMonument(Location to, Team team) {
		for (Monument monument : this.monuments) {
			if (monument.isNear(to) && monument.isOwner(team)) {
				return true;
			}
		}
		return false;
	}

	public List<Monument> getMonuments() {
		return this.monuments;
	}

	public boolean hasPlayerState(String playerName) {
		return this.playerStates.containsKey(playerName);
	}

	public void keepPlayerState(Player player) {
		PlayerInventory inventory = player.getInventory();
		ItemStack[] contents = inventory.getContents();
		
		String playerTitle = player.getName();
		if (War.war.isSpoutServer()) {
			playerTitle = SpoutManager.getPlayer(player).getTitle();
		}
		
		this.playerStates.put(
				player.getName(),
				new PlayerState(player.getGameMode(), contents, inventory
						.getHelmet(), inventory.getChestplate(), inventory
						.getLeggings(), inventory.getBoots(), player
						.getHealth(), player.getExhaustion(), player
						.getSaturation(), player.getFoodLevel(), player
						.getActivePotionEffects(), playerTitle, player
						.getLevel(), player.getExp(), player.getAllowFlight()));
	}

	public void restorePlayerState(Player player) {
		PlayerState originalState = this.playerStates.remove(player.getName());
		PlayerInventory playerInv = player.getInventory();
		if (originalState != null) {
			// prevent item hacking thru CRAFTING personal inventory slots
			this.preventItemHackingThroughOpenedInventory(player);
			
			this.playerInvFromInventoryStash(playerInv, originalState);
			player.setGameMode(originalState.getGamemode());
			player.setHealth(Math.max(Math.min(originalState.getHealth(), 20.0D), 0.0D));
			player.setExhaustion(originalState.getExhaustion());
			player.setSaturation(originalState.getSaturation());
			player.setFoodLevel(originalState.getFoodLevel());
			PotionEffectHelper.restorePotionEffects(player, originalState.getPotionEffects());
			player.setLevel(originalState.getLevel());
			player.setExp(originalState.getExp());
			player.setAllowFlight(originalState.canFly());
			
			if (War.war.isSpoutServer()) {
				SpoutManager.getPlayer(player).setTitle(originalState.getPlayerTitle());
			}
		}
		player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
	}

	private void preventItemHackingThroughOpenedInventory(Player player) {
		InventoryView openedInv = player.getOpenInventory();
		if (openedInv.getType() == InventoryType.CRAFTING) {
			// prevent abuse of personal crafting slots (this behavior doesn't seem to happen 
			// for containers like workbench and furnace - those get closed properly)
			openedInv.getTopInventory().clear();
		}
		
		// Prevent player from keeping items he was transferring in his inventory
		openedInv.setCursor(null);
	}

	private void playerInvFromInventoryStash(PlayerInventory playerInv, PlayerState originalContents) {
		playerInv.clear();
		
		playerInv.clear(playerInv.getSize() + 0);
		playerInv.clear(playerInv.getSize() + 1);
		playerInv.clear(playerInv.getSize() + 2);
		playerInv.clear(playerInv.getSize() + 3); // helmet/blockHead
		
		int invIndex = 0;
		for (ItemStack item : originalContents.getContents()) {
			if (item != null && item.getType() != Material.AIR) {
				playerInv.setItem(invIndex, item);
			}
			invIndex++;
		}
		
		if (originalContents.getHelmet() != null) {
			playerInv.setHelmet(originalContents.getHelmet());
		}
		if (originalContents.getChest() != null) {
			playerInv.setChestplate(originalContents.getChest());
		}
		if (originalContents.getLegs() != null) {
			playerInv.setLeggings(originalContents.getLegs());
		}
		if (originalContents.getFeet() != null) {
			playerInv.setBoots(originalContents.getFeet());
		}
	}

	public boolean hasMonument(String monumentName) {
		for (Monument monument : this.monuments) {
			if (monument.getName().startsWith(monumentName)) {
				return true;
			}
		}
		return false;
	}

	public Monument getMonument(String monumentName) {
		for (Monument monument : this.monuments) {
			if (monument.getName().startsWith(monumentName)) {
				return monument;
			}
		}
		return null;
	}
	
	public boolean hasBomb(String bombName) {
		for (Bomb bomb : this.bombs) {
			if (bomb.getName().equals(bombName)) {
				return true;
			}
		}
		return false;
	}

	public Bomb getBomb(String bombName) {
		for (Bomb bomb : this.bombs) {
			if (bomb.getName().startsWith(bombName)) {
				return bomb;
			}
		}
		return null;
	}
	
	public boolean hasCake(String cakeName) {
		for (Cake cake : this.cakes) {
			if (cake.getName().equals(cakeName)) {
				return true;
			}
		}
		return false;
	}

	public Cake getCake(String cakeName) {
		for (Cake cake : this.cakes) {
			if (cake.getName().startsWith(cakeName)) {
				return cake;
			}
		}
		return null;
	}

	public boolean isImportantBlock(Block block) {
		if (this.ready()) {
			for (Monument m : this.monuments) {
				if (m.getVolume().contains(block)) {
					return true;
				}
			}
			for (Bomb b : this.bombs) {
				if (b.getVolume().contains(block)) {
					return true;
				}
			}
			for (Cake c : this.cakes) {
				if (c.getVolume().contains(block)) {
					return true;
				}
			}
			for (Team t : this.teams) {
				for (Volume tVolume : t.getSpawnVolumes().values()) {
					if (tVolume.contains(block)) {
						return true;
					}
				}
				if (t.getFlagVolume() != null && t.getFlagVolume().contains(block)) {
					return true;
				}
			}
			if (this.volume.isWallBlock(block)) {
				return true;
			}
		}
		return false;
	}

	public World getWorld() {

		return this.world;
	}

	public void setWorld(World world) {
		this.world = world;
	}

	public ZoneVolume getVolume() {
		return this.volume;
	}

	public void setVolume(ZoneVolume zoneVolume) {
		this.volume = zoneVolume;
	}

	public Team getTeamByKind(TeamKind kind) {
		for (Team t : this.teams) {
			if (t.getKind() == kind) {
				return t;
			}
		}
		return null;
	}

	public boolean isNearWall(Location latestPlayerLocation) {
		if (this.volume.hasTwoCorners()) {
			if (Math.abs(this.volume.getSoutheastZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
				return true; // near east wall
			} else if (Math.abs(this.volume.getSoutheastX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
				return true; // near south wall
			} else if (Math.abs(this.volume.getNorthwestX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
				return true; // near north wall
			} else if (Math.abs(this.volume.getNorthwestZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
				return true; // near west wall
			} else if (Math.abs(this.volume.getMaxY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
				return true; // near up wall
			} else if (Math.abs(this.volume.getMinY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
				return true; // near down wall
			}
		}
		return false;
	}

	public List<Block> getNearestWallBlocks(Location latestPlayerLocation) {
		List<Block> nearestWallBlocks = new ArrayList<Block>();
		if (Math.abs(this.volume.getSoutheastZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near east wall
			Block eastWallBlock = this.world.getBlockAt(latestPlayerLocation.getBlockX() + 1, latestPlayerLocation.getBlockY() + 1, this.volume.getSoutheastZ());
			nearestWallBlocks.add(eastWallBlock);
		}

		if (Math.abs(this.volume.getSoutheastX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near south wall
			Block southWallBlock = this.world.getBlockAt(this.volume.getSoutheastX(), latestPlayerLocation.getBlockY() + 1, latestPlayerLocation.getBlockZ());
			nearestWallBlocks.add(southWallBlock);
		}

		if (Math.abs(this.volume.getNorthwestX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near north wall
			Block northWallBlock = this.world.getBlockAt(this.volume.getNorthwestX(), latestPlayerLocation.getBlockY() + 1, latestPlayerLocation.getBlockZ());
			nearestWallBlocks.add(northWallBlock);
		}

		if (Math.abs(this.volume.getNorthwestZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near west wall
			Block westWallBlock = this.world.getBlockAt(latestPlayerLocation.getBlockX(), latestPlayerLocation.getBlockY() + 1, this.volume.getNorthwestZ());
			nearestWallBlocks.add(westWallBlock);
		}

		if (Math.abs(this.volume.getMaxY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
			// near up wall
			Block upWallBlock = this.world.getBlockAt(latestPlayerLocation.getBlockX(), this.volume.getMaxY(), latestPlayerLocation.getBlockZ());
			nearestWallBlocks.add(upWallBlock);
		}

		if (Math.abs(this.volume.getMinY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
			// near down wall
			Block downWallBlock = this.world.getBlockAt(latestPlayerLocation.getBlockX(), this.volume.getMinY(), latestPlayerLocation.getBlockZ());
			nearestWallBlocks.add(downWallBlock);
		}
		return nearestWallBlocks;
		// note: y + 1 to line up 3 sided square with player eyes
	}

	public List<BlockFace> getNearestWalls(Location latestPlayerLocation) {
		List<BlockFace> walls = new ArrayList<BlockFace>();
		if (Math.abs(this.volume.getSoutheastZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near east wall
			walls.add(Direction.EAST());
		}

		if (Math.abs(this.volume.getSoutheastX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near south wall
			walls.add(Direction.SOUTH());
		}

		if (Math.abs(this.volume.getNorthwestX() - latestPlayerLocation.getBlockX()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockZ() <= this.volume.getNorthwestZ() && latestPlayerLocation.getBlockZ() >= this.volume.getSoutheastZ() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near north wall
			walls.add(Direction.NORTH());
		}

		if (Math.abs(this.volume.getNorthwestZ() - latestPlayerLocation.getBlockZ()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getSoutheastX() && latestPlayerLocation.getBlockX() >= this.volume.getNorthwestX() && latestPlayerLocation.getBlockY() >= this.volume.getMinY() && latestPlayerLocation.getBlockY() <= this.volume.getMaxY()) {
			// near west wall
			walls.add(Direction.WEST());
		}

		if (Math.abs(this.volume.getMaxY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
			// near up wall
			walls.add(BlockFace.UP);
		}

		if (Math.abs(this.volume.getMinY() - latestPlayerLocation.getBlockY()) < this.minSafeDistanceFromWall && latestPlayerLocation.getBlockX() <= this.volume.getMaxX() && latestPlayerLocation.getBlockX() >= this.volume.getMinX() && latestPlayerLocation.getBlockZ() <= this.volume.getMaxZ() && latestPlayerLocation.getBlockZ() >= this.volume.getMinZ()) {
			// near down wall
			walls.add(BlockFace.DOWN);
		}
		return walls;
	}

	public ZoneWallGuard getPlayerZoneWallGuard(String name, BlockFace wall) {
		for (ZoneWallGuard guard : this.zoneWallGuards) {
			if (guard.getPlayer().getName().equals(name) && wall == guard.getWall()) {
				return guard;
			}
		}
		return null;
	}

	public boolean protectZoneWallAgainstPlayer(Player player) {
		List<BlockFace> nearestWalls = this.getNearestWalls(player.getLocation());
		boolean protecting = false;
		for (BlockFace wall : nearestWalls) {
			ZoneWallGuard guard = this.getPlayerZoneWallGuard(player.getName(), wall);
			if (guard != null) {
				// already protected, need to move the guard
				guard.updatePlayerPosition(player.getLocation());
			} else {
				// new guard
				guard = new ZoneWallGuard(player, War.war, this, wall);
				this.zoneWallGuards.add(guard);
			}
			protecting = true;
		}
		return protecting;
	}

	public void dropZoneWallGuardIfAny(Player player) {
		List<ZoneWallGuard> playerGuards = new ArrayList<ZoneWallGuard>();
		for (ZoneWallGuard guard : this.zoneWallGuards) {
			if (guard.getPlayer().getName().equals(player.getName())) {
				playerGuards.add(guard);
				guard.deactivate();
			}
		}
		// now remove those zone guards
		for (ZoneWallGuard playerGuard : playerGuards) {
			this.zoneWallGuards.remove(playerGuard);
		}
		playerGuards.clear();
	}

	public void setLobby(ZoneLobby lobby) {
		this.lobby = lobby;
	}

	public ZoneLobby getLobby() {
		return this.lobby;
	}

	static final Comparator<Team> LEAST_PLAYER_COUNT_ORDER = new Comparator<Team>() {
		@Override
		public int compare(Team arg0, Team arg1) {
			return arg0.getPlayers().size() - arg1.getPlayers().size();
		}
	};

	public Team autoAssign(Player player) {
		Collections.sort(teams, LEAST_PLAYER_COUNT_ORDER);
		Team lowestNoOfPlayers = null;
		for (Team team : this.teams) {
			if (War.war.canPlayWar(player, team)) {
				lowestNoOfPlayers = team;
				break;
			}
		}
		if (lowestNoOfPlayers != null) {
			this.assign(player, lowestNoOfPlayers);
		}
		return lowestNoOfPlayers;
	}

	/**
	 * Assign a player to a specific team.
	 * 
	 * @param player
	 *            Player to assign to team.
	 * @param team
	 *            Team to add the player to.
	 * @return false if player does not have permission to join this team.
	 */
	public boolean assign(Player player, Team team) {
		if (!War.war.canPlayWar(player, team)) {
			War.war.badMsg(player, "join.permission.single");
			return false;
		}
		if (player.getWorld() != this.getWorld()) {
			player.teleport(this.getWorld().getSpawnLocation());
		}
		team.addPlayer(player);
		team.resetSign();
		if (this.hasPlayerState(player.getName())) {
			War.war.getLogger().log(Level.WARNING, "Player {0} in warzone {1} already has a stored state - they may have lost items",
					new Object[] {player.getName(), this.getName()});
			this.playerStates.remove(player.getName());
		}
		this.getReallyDeadFighters().remove(player.getName());
		this.keepPlayerState(player);
		War.war.msg(player, "join.inventorystored");
		this.respawnPlayer(team, player);
		this.broadcast("join.broadcast", player.getName(), team.getKind().getFormattedName());
		return true;
	}
	
	private void dropItems(Location location, ItemStack[] items) {
		for (ItemStack item : items) {
			if (item == null || item.getType() == Material.AIR) {
				continue;
			}
			location.getWorld().dropItem(location, item);
		}
	}
	
	private Random killSeed = new Random();
	
	/**
	 * Send death messages and process other records before passing off the
	 * death to the {@link #handleDeath(Player)} method.
	 * @param attacker Player who killed the defender
	 * @param defender Player who was killed
	 * @param damager Entity who caused the damage. Usually an arrow. Used for
	 * specific death messages. Can be null.
	 */
	public void handleKill(Player attacker, Player defender, Entity damager) {
		Team attackerTeam = this.getPlayerTeam(attacker.getName());
		Team defenderTeam = this.getPlayerTeam(defender.getName());
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.DEATHMESSAGES)) {
			String attackerString = attackerTeam.getKind().getColor() + attacker.getName();
			String defenderString = defenderTeam.getKind().getColor() + defender.getName();
			Material killerWeapon = attacker.getItemInHand().getType();
			String weaponString = killerWeapon.toString();
			if (attacker.getItemInHand().hasItemMeta() && attacker.getItemInHand().getItemMeta().hasDisplayName()) {
				weaponString = attacker.getItemInHand().getItemMeta().getDisplayName() + ChatColor.WHITE;
			}
			if (killerWeapon == Material.AIR) {
				weaponString = War.war.getString("pvp.kill.weapon.hand");
			} else if (killerWeapon == Material.BOW || damager instanceof Arrow) {
				int rand = killSeed.nextInt(3);
				if (rand == 0) {
					weaponString = War.war.getString("pvp.kill.weapon.bow");
				} else {
					weaponString = War.war.getString("pvp.kill.weapon.aim");
				}
			} else if (damager instanceof Projectile) {
				weaponString = War.war.getString("pvp.kill.weapon.aim");
			}
			String adjectiveString = War.war.getDeadlyAdjectives().isEmpty() ? "" : War.war.getDeadlyAdjectives().get(this.killSeed.nextInt(War.war.getDeadlyAdjectives().size()));
			String verbString = War.war.getKillerVerbs().isEmpty() ? "" : War.war.getKillerVerbs().get(this.killSeed.nextInt(War.war.getKillerVerbs().size()));
			this.broadcast("pvp.kill.format", attackerString + ChatColor.WHITE, adjectiveString,
					weaponString.toLowerCase().replace('_', ' '), verbString, defenderString);
		}
		this.addKillCount(attacker.getName(), 1);
		this.addKillDeathRecord(attacker, 1, 0);
		this.addKillDeathRecord(defender, 0, 1);
		if (attackerTeam.getTeamConfig().resolveBoolean(TeamConfig.XPKILLMETER)) {
			attacker.setLevel(this.getKillCount(attacker.getName()));
		}
		if (attackerTeam.getTeamConfig().resolveBoolean(TeamConfig.KILLSTREAK)) {
			War.war.getKillstreakReward().rewardPlayer(attacker, this.getKillCount(attacker.getName()));
		}
		if (this.getScoreboard() != null && this.getScoreboardType() == ScoreboardType.TOPKILLS) {
			Objective obj = this.getScoreboard().getObjective("Top kills");
			obj.getScore(attacker).setScore(this.getKillCount(attacker.getName()));
		}
		if (defenderTeam.getTeamConfig().resolveBoolean(TeamConfig.INVENTORYDROP)) {
			dropItems(defender.getLocation(), defender.getInventory().getContents());
			dropItems(defender.getLocation(), defender.getInventory().getArmorContents());
		}
		this.handleDeath(defender);
	}
	
	/**
	 * Handle death messages before passing to {@link #handleDeath(Player)}
	 * for post-processing. It's like
	 * {@link #handleKill(Player, Player, Entity)}, but only for suicides.
	 * @param player Player who killed himself
	 */
	public void handleSuicide(Player player) {
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.DEATHMESSAGES)) {
			String defenderString = this.getPlayerTeam(player.getName()).getKind().getColor() + player.getName() + ChatColor.WHITE;
			this.broadcast("pvp.kill.self", defenderString);
		}
		this.handleDeath(player);
	}
	
	/**
	 * Handle a player killed naturally (like by a dispenser or explosion).
	 * @param player Player killed
	 * @param event Event causing damage
	 */
	public void handleNaturalKill(Player player, EntityDamageEvent event) {
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.DEATHMESSAGES)) {
			String defenderString = this.getPlayerTeam(player.getName()).getKind().getColor() + player.getName() + ChatColor.WHITE;
			if (event instanceof EntityDamageByEntityEvent
					&& ((EntityDamageByEntityEvent) event).getDamager() instanceof TNTPrimed) {
				this.broadcast("pvp.death.explosion", defenderString + ChatColor.WHITE);
			} else if (event.getCause() == DamageCause.FIRE || event.getCause() == DamageCause.FIRE_TICK 
					|| event.getCause() == DamageCause.LAVA || event.getCause() == DamageCause.LIGHTNING) {
				this.broadcast("pvp.death.fire", defenderString);
			} else if (event.getCause() == DamageCause.DROWNING) {
				this.broadcast("pvp.death.drown", defenderString);
			} else if (event.getCause() == DamageCause.FALL) {
				this.broadcast("pvp.death.fall", defenderString);
			} else {
				this.broadcast("pvp.death.other", defenderString);
			}
		}
		this.handleDeath(player);
	}

	/**
	 * Cleanup after a player who has died. This decrements the team's
	 * remaining lifepool, drops stolen flags, and respawns the player.
	 * It also handles team lose and score cap conditions.
	 * This method is synchronized to prevent concurrent battle resets.
	 * @param player Player who died
	 */
	public synchronized void handleDeath(Player player) {
		Team playerTeam = this.getPlayerTeam(player.getName());
		Validate.notNull(playerTeam, "Can't find team for dead player " + player.getName());
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.REALDEATHS)) {
			this.getReallyDeadFighters().add(player.getName());
		} else {
			this.respawnPlayer(playerTeam, player);
		}
		if (playerTeam.getRemainingLifes() <= 0) {
			handleTeamLoss(playerTeam, player);
		} else {
			this.dropAllStolenObjects(player, false);
			playerTeam.setRemainingLives(playerTeam.getRemainingLifes() - 1);
			// Lifepool empty warning
			if (playerTeam.getRemainingLifes() == 0) {
				this.broadcast("zone.lifepool.empty", playerTeam.getName());
			}
		}
		playerTeam.resetSign();
	}
	
	private void handleTeamLoss(Team losingTeam, Player player) {
		StringBuilder teamScores = new StringBuilder();
		List<Team> winningTeams = new ArrayList<Team>(teams.size());
		for (Team team : this.teams) {
			if (team.getPlayers().isEmpty())
				continue;
			if (team != losingTeam) {
				team.addPoint();
				team.resetSign();
				winningTeams.add(team);
			}
			teamScores.append(String.format("\n%s (%d/%d) ", team.getName(), team.getPoints(), team.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)));
			team.sendAchievement("Round over! " + losingTeam.getKind().getFormattedName(), "ran out of lives.", losingTeam.getKind().getBlockHead(), 10000);
		}
		this.broadcast("zone.battle.end", losingTeam.getName(), player.getName());
		WarBattleWinEvent event1 = new WarBattleWinEvent(this, winningTeams);
		War.war.getServer().getPluginManager().callEvent(event1);
		if (!teamScores.toString().isEmpty()) {
			this.broadcast("zone.battle.newscores", teamScores.toString());
		}
		if (War.war.getMysqlConfig().isEnabled() && War.war.getMysqlConfig().isLoggingEnabled()) {
			LogKillsDeathsJob logKillsDeathsJob = new LogKillsDeathsJob(ImmutableList.copyOf(this.getKillsDeathsTracker()));
			War.war.getServer().getScheduler().runTaskAsynchronously(War.war, logKillsDeathsJob);
		}
		this.getKillsDeathsTracker().clear();
		if (!detectScoreCap()) {
			this.broadcast("zone.battle.reset");
			if (this.getWarzoneConfig().getBoolean(WarzoneConfig.RESETBLOCKS)) {
				this.reinitialize();
			} else {
				this.initializeZone();
			}
		}
	}

	/**
	 * Check if a team has achieved max score "score cap".
	 * @return true if team has achieved max score, false otherwise.
	 */
	public boolean detectScoreCap() {
		StringBuilder winnersStr = new StringBuilder();
		for (Team team : this.teams) {
			if (team.getPoints() >= team.getTeamConfig().resolveInt(TeamConfig.MAXSCORE)) {
				winnersStr.append(team.getName()).append(' ');
			}
		}
		if (!winnersStr.toString().isEmpty())
			this.handleScoreCapReached(winnersStr.toString());
		return !winnersStr.toString().isEmpty();
	}

	public void reinitialize() {
		this.isReinitializing = true;
		this.getVolume().resetBlocksAsJob();
	}

	public void handlePlayerLeave(Player player, Location destination, PlayerMoveEvent event, boolean removeFromTeam) {
		this.handlePlayerLeave(player);
		event.setTo(destination);
	}

	public void handlePlayerLeave(Player player, Location destination, boolean removeFromTeam) {
		this.handlePlayerLeave(player);
		player.teleport(destination);
	}

	private void handlePlayerLeave(Player player) {
		Team playerTeam = Team.getTeamByPlayerName(player.getName());
		if (playerTeam != null) {
			playerTeam.removePlayer(player);
			this.broadcast("leave.broadcast", playerTeam.getKind().getColor() + player.getName() + ChatColor.WHITE);
			playerTeam.resetSign();
			if (this.getPlayerCount() == 0 && this.getWarzoneConfig().getBoolean(WarzoneConfig.RESETONEMPTY)) {
				// reset the zone for a new game when the last player leaves
				for (Team team : this.getTeams()) {
					team.resetPoints();
					team.setRemainingLives(team.getTeamConfig().resolveInt(TeamConfig.LIFEPOOL));
				}
				if (!this.isReinitializing()) {
					this.reinitialize();
					War.war.getLogger().log(Level.INFO, "Last player left warzone {0}. Warzone blocks resetting automatically...", new Object[] {this.getName()});
				}
			}
			
			WarPlayerLeaveEvent event1 = new WarPlayerLeaveEvent(player.getName());
			War.war.getServer().getPluginManager().callEvent(event1);
		}
	}

	public boolean isEnemyTeamFlagBlock(Team playerTeam, Block block) {
		for (Team team : this.teams) {
			if (!team.getName().equals(playerTeam.getName()) && team.isTeamFlagBlock(block)) {
				return true;
			}
		}
		return false;
	}
	
	public boolean isFlagBlock(Block block) {
		for (Team team : this.teams) {
			if (team.isTeamFlagBlock(block)) {
				return true;
			}
		}
		return false;
	}

	public Team getTeamForFlagBlock(Block block) {
		for (Team team : this.teams) {
			if (team.isTeamFlagBlock(block)) {
				return team;
			}
		}
		return null;
	}
	
	public boolean isBombBlock(Block block) {
		for (Bomb bomb : this.bombs) {
			if (bomb.isBombBlock(block.getLocation())) {
				return true;
			}
		}
		return false;
	}

	public Bomb getBombForBlock(Block block) {
		for (Bomb bomb : this.bombs) {
			if (bomb.isBombBlock(block.getLocation())) {
				return bomb;
			}
		}
		return null;
	}
	
	public boolean isCakeBlock(Block block) {
		for (Cake cake : this.cakes) {
			if (cake.isCakeBlock(block.getLocation())) {
				return true;
			}
		}
		return false;
	}

	public Cake getCakeForBlock(Block block) {
		for (Cake cake : this.cakes) {
			if (cake.isCakeBlock(block.getLocation())) {
				return cake;
			}
		}
		return null;
	}

	// Flags
	public void addFlagThief(Team lostFlagTeam, String flagThief) {
		this.flagThieves.put(flagThief, lostFlagTeam);
		WarPlayerThiefEvent event1 = new WarPlayerThiefEvent(Bukkit.getPlayerExact(flagThief), WarPlayerThiefEvent.StolenObject.FLAG);
		War.war.getServer().getPluginManager().callEvent(event1);
	}

	public boolean isFlagThief(String suspect) {
		if (this.flagThieves.containsKey(suspect)) {
			return true;
		}
		return false;
	}

	public Team getVictimTeamForFlagThief(String thief) {
		return this.flagThieves.get(thief);
	}

	public void removeFlagThief(String thief) {
		this.flagThieves.remove(thief);
	}

	// Bomb
	public void addBombThief(Bomb bomb, String bombThief) {
		this.bombThieves.put(bombThief, bomb);
		WarPlayerThiefEvent event1 = new WarPlayerThiefEvent(Bukkit.getPlayerExact(bombThief), WarPlayerThiefEvent.StolenObject.BOMB);
		War.war.getServer().getPluginManager().callEvent(event1);
	}

	public boolean isBombThief(String suspect) {
		if (this.bombThieves.containsKey(suspect)) {
			return true;
		}
		return false;
	}

	public Bomb getBombForThief(String thief) {
		return this.bombThieves.get(thief);
	}

	public void removeBombThief(String thief) {
		this.bombThieves.remove(thief);
	}
	
	// Cake
	
	public void addCakeThief(Cake cake, String cakeThief) {
		this.cakeThieves.put(cakeThief, cake);
		WarPlayerThiefEvent event1 = new WarPlayerThiefEvent(Bukkit.getPlayerExact(cakeThief), WarPlayerThiefEvent.StolenObject.CAKE);
		War.war.getServer().getPluginManager().callEvent(event1);
	}

	public boolean isCakeThief(String suspect) {
		if (this.cakeThieves.containsKey(suspect)) {
			return true;
		}
		return false;
	}

	public Cake getCakeForThief(String thief) {
		return this.cakeThieves.get(thief);
	}

	public void removeCakeThief(String thief) {
		this.cakeThieves.remove(thief);
	}

	public void clearThieves() {
		this.flagThieves.clear();
		this.bombThieves.clear();
		this.cakeThieves.clear();
	}

	public boolean isTeamFlagStolen(Team team) {
		for (String playerKey : this.flagThieves.keySet()) {
			if (this.flagThieves.get(playerKey).getName().equals(team.getName())) {
				return true;
			}
		}
		return false;
	}
	
	public void handleScoreCapReached(String winnersStr) {
		// Score cap reached. Reset everything.
		this.isEndOfGame = true;
		List<Team> winningTeams = new ArrayList<Team>(teams.size());
		for (String team : winnersStr.split(" ")) {
			winningTeams.add(this.getTeamByKind(TeamKind.getTeam(team)));
		}
		WarScoreCapEvent event1 = new WarScoreCapEvent(winningTeams);
		War.war.getServer().getPluginManager().callEvent(event1);
		
		for (Team t : this.getTeams()) {
			if (War.war.isSpoutServer()) {
				for (Player p : t.getPlayers()) {
					SpoutPlayer sp = SpoutManager.getPlayer(p);
					if (sp.isSpoutCraftEnabled()) {
		                sp.sendNotification(
		                		SpoutDisplayer.cleanForNotification("Match won! " + ChatColor.WHITE + "Winners:"),
		                		SpoutDisplayer.cleanForNotification(SpoutDisplayer.addMissingColor(winnersStr, this)),
		                		Material.CAKE,
		                		(short)0,
		                		10000);
					}
				}
			}
			String winnersStrAndExtra = "Score cap reached. Game is over! Winning team(s): " + winnersStr;
			winnersStrAndExtra += ". Resetting warzone and your inventory...";
			t.teamcast(winnersStrAndExtra);
			double ecoReward = t.getTeamConfig().resolveDouble(TeamConfig.ECOREWARD); 
			boolean doEcoReward = ecoReward != 0 && War.war.getEconomy() != null;
			for (Iterator<Player> it = t.getPlayers().iterator(); it.hasNext();) {
				Player tp = it.next();
				it.remove(); // Remove player from team first to prevent anti-tp
				t.removePlayer(tp);
				tp.teleport(this.getEndTeleport(LeaveCause.SCORECAP));
				if (winnersStr.contains(t.getName())) {
					// give reward
					rewardPlayer(tp, t.getInventories().resolveReward());
					if (doEcoReward) {
						EconomyResponse r;
						if (ecoReward > 0) {
							r = War.war.getEconomy().depositPlayer(tp.getName(), ecoReward);
						} else {
							r = War.war.getEconomy().withdrawPlayer(tp.getName(), ecoReward);
						}
						if (!r.transactionSuccess()) {
							War.war.getLogger().log(Level.WARNING,
								"Failed to reward player {0} ${1}. Error: {2}",
								new Object[] {tp.getName(), ecoReward, r.errorMessage});
						}
					}
				}
			}
			t.resetPoints();
			t.getPlayers().clear(); // empty the team
			t.resetSign();
		}
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.RESETBLOCKS)) {
			this.reinitialize();
		} else {
			this.initializeZone();
		}
	}

	public void rewardPlayer(Player player, Map<Integer, ItemStack> reward) {
		for (Integer slot : reward.keySet()) {
			ItemStack item = reward.get(slot);
			if (item != null) {
				player.getInventory().addItem(item);
			}
		}
	}

	public boolean isDeadMan(String playerName) {
		if (this.deadMenInventories.containsKey(playerName)) {
			return true;
		}
		return false;
	}

	public void restoreDeadmanInventory(Player player) {
		if (this.isDeadMan(player.getName())) {
			this.playerInvFromInventoryStash(player.getInventory(), this.deadMenInventories.get(player.getName()));
			this.deadMenInventories.remove(player.getName());
		}
	}

	public void setRallyPoint(Location location) {
		this.rallyPoint = location;
	}

	public Location getRallyPoint() {
		return this.rallyPoint;
	}

	public void unload() {
		War.war.log("Unloading zone " + this.getName() + "...", Level.INFO);
		for (Team team : this.getTeams()) {
			for (Iterator<Player> it = team.getPlayers().iterator(); it.hasNext(); ) {
				final Player player = it.next();
				it.remove();
				team.removePlayer(player);
				player.teleport(this.getTeleport());
			}
		}
		if (this.getLobby() != null) {
			this.getLobby().getVolume().resetBlocks();
		}
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.RESETONUNLOAD)) {
			this.getVolume().resetBlocks();
		}
	}

	public boolean isEnoughPlayers() {
		int teamsWithEnough = 0;
		for (Team team : teams) {
			if (team.getPlayers().size() >= this.getWarzoneConfig().getInt(WarzoneConfig.MINPLAYERS)) {
				teamsWithEnough++;
			}
		}
		if (teamsWithEnough >= this.getWarzoneConfig().getInt(WarzoneConfig.MINTEAMS)) {
			return true;
		}
		return false;
	}

	public HashMap<String, LoadoutSelection> getLoadoutSelections() {
		return loadoutSelections;
	}

	public boolean isAuthor(Player player) {
		// if no authors, all zonemakers can edit the zone
		return authors.size() == 0 || authors.contains(player.getName());
	}
		
	public void addAuthor(String playerName) {
		authors.add(playerName);
	}
	
	public List<String> getAuthors() {
		return this.authors;
	}

	public String getAuthorsString() {
		String authors = "";
		for (String author : this.getAuthors()) {
			authors += author + ",";
		}
		return authors;
	}

	public void equipPlayerLoadoutSelection(Player player, Team playerTeam, boolean isFirstRespawn, boolean isToggle) {
		LoadoutSelection selection = this.getLoadoutSelections().get(player.getName());
		if (selection != null && !this.isRespawning(player) && playerTeam.getPlayers().contains(player)) {
			// Make sure that inventory resets dont occur if player has already tp'ed out (due to game end, or somesuch) 
			// - repawn timer + this method is why inventories were getting wiped as players exited the warzone. 
			List<Loadout> loadouts = playerTeam.getInventories().resolveNewLoadouts();
			List<String> sortedNames = LoadoutYmlMapper.sortNames(Loadout.toLegacyFormat(loadouts));
			sortedNames.remove("first");
			for (Iterator<String> it = sortedNames.iterator(); it.hasNext();) {
				String loadoutName = it.next();
				Loadout ldt = Loadout.getLoadout(loadouts, loadoutName);
				if (ldt.requiresPermission() && !player.hasPermission(ldt.getPermission())) {
					it.remove();
				}
			}
			if (sortedNames.isEmpty()) {
				// Fix for zones that mistakenly only specify a `first' loadout, but do not add any others.
				this.resetInventory(playerTeam, player, Collections.<Integer, ItemStack>emptyMap());
				War.war.msg(player, "404 No loadouts found");
				return;
			}
			int currentIndex = selection.getSelectedIndex();
			Loadout firstLoadout = Loadout.getLoadout(loadouts, "first");
			int i = 0;
			Iterator<String> it = sortedNames.iterator();
			while (it.hasNext()) {
				String name = (String) it.next();
				if (i == currentIndex) {
					if (playerTeam.getTeamConfig().resolveBoolean(TeamConfig.PLAYERLOADOUTASDEFAULT) && name.equals("default")) {
						// Use player's own inventory as loadout
						this.resetInventory(playerTeam, player, this.getPlayerInventoryFromSavedState(player));
					} else if (isFirstRespawn && firstLoadout != null && name.equals("default")
							&& (firstLoadout.requiresPermission() ? player.hasPermission(firstLoadout.getPermission()) : true)) {
						// Get the loadout for the first spawn
						this.resetInventory(playerTeam, player, Loadout.getLoadout(loadouts, "first").getContents());
					} else {
						// Use the loadout from the list in the settings
						this.resetInventory(playerTeam, player, Loadout.getLoadout(loadouts, name).getContents());
					}
					if (isFirstRespawn && playerTeam.getInventories().resolveLoadouts().keySet().size() > 1 || isToggle) {
						War.war.msg(player, "zone.loadout.equip", name);
					}
				}
				i++;
			}
		}
	}

	private HashMap<Integer, ItemStack> getPlayerInventoryFromSavedState(Player player) {
		HashMap<Integer, ItemStack> playerItems = new HashMap<Integer, ItemStack>();
		PlayerState originalState = this.playerStates.get(player.getName());

		if (originalState != null) {
			int invIndex = 0;
			playerItems = new HashMap<Integer, ItemStack>();
			for (ItemStack item : originalState.getContents()) {
				if (item != null && item.getType() != Material.AIR) {
					playerItems.put(invIndex, item);
				}
				invIndex++;
			}
			if (originalState.getFeet() != null) {
				playerItems.put(100, originalState.getFeet());
			}
			if (originalState.getLegs() != null) {
				playerItems.put(101, originalState.getLegs());
			}
			if (originalState.getChest() != null) {
				playerItems.put(102, originalState.getChest());
			}
			if (originalState.getHelmet() != null) {
				playerItems.put(103, originalState.getHelmet());
			}
			
			if (War.war.isSpoutServer()) {
				SpoutManager.getPlayer(player).setTitle(originalState.getPlayerTitle());
			}
		}
		
		return playerItems;
	}

	public WarzoneConfigBag getWarzoneConfig() {
		return this.warzoneConfig;
	}
	
	public TeamConfigBag getTeamDefaultConfig() {
		return this.teamDefaultConfig;
	}

	public InventoryBag getDefaultInventories() {
		return this.defaultInventories ;
	}

	public List<Bomb> getBombs() {
		return bombs;
	}

	public List<Cake> getCakes() {
		return cakes;
	}

	public List<String> getReallyDeadFighters() {
		return this.reallyDeadFighters ;
	}

	public boolean isEndOfGame() {
		return this.isEndOfGame;
	}

	public boolean isReinitializing() {
		return this.isReinitializing;
	}

//	public Object getGameEndLock() {
//		return gameEndLock;
//	}

	public void setName(String newName) {
		this.name = newName;
		this.volume.setName(newName);
	}

	public HubLobbyMaterials getLobbyMaterials() {
		return this.lobbyMaterials;
	}

	public void setLobbyMaterials(HubLobbyMaterials lobbyMaterials) {
		this.lobbyMaterials = lobbyMaterials;
	}

	public boolean isOpponentSpawnPeripheryBlock(Team team, Block block) {
		for (Team maybeOpponent : this.getTeams()) {
			if (maybeOpponent != team) {
				for (Volume teamSpawnVolume : maybeOpponent.getSpawnVolumes().values()) {
					Volume periphery = new Volume(new Location(
							teamSpawnVolume.getWorld(),
							teamSpawnVolume.getMinX() - 1,
							teamSpawnVolume.getMinY() - 1,
							teamSpawnVolume.getMinZ() - 1), new Location(
							teamSpawnVolume.getWorld(),
							teamSpawnVolume.getMaxX() + 1,
							teamSpawnVolume.getMaxY() + 1,
							teamSpawnVolume.getMaxZ() + 1));
					if (periphery.contains(block)) {
						return true;
					}
				}
			}
		}
		return false;
	}

	public void setWarzoneMaterials(WarzoneMaterials warzoneMaterials) {
		this.warzoneMaterials = warzoneMaterials;
	}

	public WarzoneMaterials getWarzoneMaterials() {
		return warzoneMaterials;
	}

	public Scoreboard getScoreboard() {
		return scoreboard;
	}

	public ScoreboardType getScoreboardType() {
		return this.getWarzoneConfig().getScoreboardType(WarzoneConfig.SCOREBOARD);
	}
	public boolean hasKillCount(String player) {
		return killCount.containsKey(player);
	}

	public int getKillCount(String player) {
		return killCount.get(player);
	}

	public void setKillCount(String player, int totalKills) {
		if (totalKills < 0) {
			throw new IllegalArgumentException("Amount of kills to set cannot be a negative number.");
		}
		killCount.put(player, totalKills);
	}

	public void addKillCount(String player, int amount) {
		if (amount < 0) {
			throw new IllegalArgumentException("Amount of kills to add cannot be a negative number.");
		}
		killCount.put(player, killCount.get(player) + amount);
	}

	public void addKillDeathRecord(OfflinePlayer player, int kills, int deaths) {
		for (Iterator<KillsDeathsRecord> it = this.killsDeathsTracker.iterator(); it.hasNext();) {
			LogKillsDeathsJob.KillsDeathsRecord kdr = it.next();
			if (kdr.getPlayer().equals(player)) {
				kills += kdr.getKills();
				deaths += kdr.getDeaths();
				it.remove();
			}
		}
		LogKillsDeathsJob.KillsDeathsRecord kdr = new LogKillsDeathsJob.KillsDeathsRecord(player, kills, deaths);
		this.killsDeathsTracker.add(kdr);
	}

	public List<LogKillsDeathsJob.KillsDeathsRecord> getKillsDeathsTracker() {
		return killsDeathsTracker;
	}

	/**
	 * Send a message to all teams.
	 * @param message Message or key to translate.
	 */
	public void broadcast(String message) {
		for (Team team : this.teams) {
			team.teamcast(message);
		}
	}

	/**
	 * Send a message to all teams.
	 * @param message Message or key to translate.
	 * @param args Arguments for the formatter.
	 */
	public void broadcast(String message, Object... args) {
		for (Team team : this.teams) {
			team.teamcast(message, args);
		}
	}

	/**
	 * Get a list of all players in the warzone. The list is immutable. If you
	 * need to modify the player list, you must use the per-team lists
	 * 
	 * @return list containing all team players.
	 */
	public List<Player> getPlayers() {
		List<Player> players = new ArrayList<Player>();
		for (Team team : this.teams) {
			players.addAll(team.getPlayers());
		}
		return players;
	}

	/**
	 * Get the amount of players in all teams in this warzone.
	 * 
	 * @return total player count
	 */
	public int getPlayerCount() {
		int count = 0;
		for (Team team : this.teams) {
			count += team.getPlayers().size();
		}
		return count;
	}

	/**
	 * Get the amount of players in all teams in this warzone. Same as
	 * {@link #getPlayerCount()}, except only checks teams that the specified
	 * player has permission to join.
	 * 
	 * @param target
	 *            Player to check for permissions.
	 * @return total player count in teams the player has access to.
	 */
	public int getPlayerCount(Permissible target) {
		int playerCount = 0;
		for (Team team : this.teams) {
			if (target.hasPermission(team.getTeamConfig().resolveString(
					TeamConfig.PERMISSION))) {
				playerCount += team.getPlayers().size();
			}
		}
		return playerCount;
	}

	/**
	 * Get the total capacity of all teams in this zone. This should be
	 * preferred over {@link TeamConfig#TEAMSIZE} as that can differ per team.
	 * 
	 * @return capacity of all teams in this zone
	 */
	public int getTotalCapacity() {
		int capacity = 0;
		for (Team team : this.teams) {
			capacity += team.getTeamConfig().resolveInt(TeamConfig.TEAMSIZE);
		}
		return capacity;
	}

	/**
	 * Get the total capacity of all teams in this zone. Same as
	 * {@link #getTotalCapacity()}, except only checks teams that the specified
	 * player has permission to join.
	 * 
	 * @param target
	 *            Player to check for permissions.
	 * @return capacity of teams the player has access to.
	 */
	public int getTotalCapacity(Permissible target) {
		int capacity = 0;
		for (Team team : this.teams) {
			if (target.hasPermission(team.getTeamConfig().resolveString(
					TeamConfig.PERMISSION))) {
				capacity += team.getTeamConfig()
						.resolveInt(TeamConfig.TEAMSIZE);
			}
		}
		return capacity;
	}

	/**
	 * Check if all teams are full.
	 * 
	 * @return true if all teams are full, false otherwise.
	 */
	public boolean isFull() {
		return this.getPlayerCount() == this.getTotalCapacity();
	}

	/**
	 * Check if all teams are full. Same as {@link #isFull()}, except only
	 * checks teams that the specified player has permission to join.
	 * 
	 * @param target
	 *            Player to check for permissions.
	 * @return true if all teams are full, false otherwise.
	 */
	public boolean isFull(Permissible target) {
		return this.getPlayerCount(target) == this.getTotalCapacity(target);
	}

	public void dropAllStolenObjects(Player player, boolean quiet) {
		if (this.isFlagThief(player.getName())) {
			Team victimTeam = this.getVictimTeamForFlagThief(player.getName());

			this.removeFlagThief(player.getName());

			// Bring back flag of victim team
			victimTeam.getFlagVolume().resetBlocks();
			victimTeam.initializeTeamFlag();

			if (!quiet) {
				this.broadcast("drop.flag.broadcast", player.getName(), victimTeam.getKind().getColor() + victimTeam.getName() + ChatColor.WHITE);
			}
		} else if (this.isCakeThief(player.getName())) {
			Cake cake = this.getCakeForThief(player.getName());

			this.removeCakeThief(player.getName());

			// Bring back cake
			cake.getVolume().resetBlocks();
			cake.addCakeBlocks();

			if (!quiet) {
				this.broadcast("drop.cake.broadcast", player.getName(), ChatColor.GREEN + cake.getName() + ChatColor.WHITE);
			}
		} else if (this.isBombThief(player.getName())) {
			Bomb bomb = this.getBombForThief(player.getName());

			this.removeBombThief(player.getName());

			// Bring back bomb
			bomb.getVolume().resetBlocks();
			bomb.addBombBlocks();

			if (!quiet) {
				this.broadcast("drop.bomb.broadcast", player.getName(), ChatColor.GREEN + bomb.getName() + ChatColor.WHITE);
			}
		}
	}

	/**
	 * Get the proper ending teleport location for players leaving the warzone.
	 * <p>
	 * Specifically, it gets teleports in this order:
	 * <ul>
	 * <li>Rally point (if scorecap)
	 * <li>Warhub (if autojoin)
	 * <li>Lobby
	 * </ul>
	 * </p>
	 * @param reason Reason for leaving zone
	 * @return
	 */
	public Location getEndTeleport(LeaveCause reason) {
		if (reason.useRallyPoint() && this.getRallyPoint() != null) {
			return this.getRallyPoint();
		}
		if (this.getWarzoneConfig().getBoolean(WarzoneConfig.AUTOJOIN)
				&& War.war.getWarHub() != null) {
			return War.war.getWarHub().getLocation();
		}
		return this.getTeleport();
	}

	public Volume loadStructure(String volName, World world) throws SQLException {
		return loadStructure(volName, world, ZoneVolumeMapper.getZoneConnection(volume, name, world));
	}

	public Volume loadStructure(String volName, Connection zoneConnection) throws SQLException {
		return loadStructure(volName, world, zoneConnection);
	}

	public Volume loadStructure(String volName, World world, Connection zoneConnection) throws SQLException {
		Volume volume = new Volume(volName, world);
		if (!containsTable(String.format("structure_%d_corners", volName.hashCode() & Integer.MAX_VALUE), zoneConnection)) {
			volume = VolumeMapper.loadVolume(volName, name, world);
			ZoneVolumeMapper.saveStructure(volume, zoneConnection);
			War.war.getLogger().log(Level.INFO, "Stuffed structure {0} into database for warzone {1}", new Object[] {volName, name});
			return volume;
		}
		ZoneVolumeMapper.loadStructure(volume, zoneConnection);
		return volume;
	}

	private boolean containsTable(String table, Connection connection) throws SQLException {
		PreparedStatement stmt = connection.prepareStatement("SELECT COUNT(*) AS ct FROM sqlite_master WHERE type = ? AND name = ?");
		stmt.setString(1, "table");
		stmt.setString(2, table);
		ResultSet resultSet = stmt.executeQuery();
		try {
			return resultSet.next() && resultSet.getInt("ct") > 0;
		} finally {
			resultSet.close();
			stmt.close();
		}
	}

	/**
	 * Check if a player has stolen from a warzone flag, bomb, or cake.
	 * @param suspect Player to check.
	 * @return true if suspect has stolen a structure.
	 */
	public boolean isThief(String suspect) {
		return this.isFlagThief(suspect) || this.isBombThief(suspect) || this.isCakeThief(suspect);
	}
}